package com.fr.report.cellElement.core;

import com.fr.base.FRContext;
import com.fr.base.StringUtils;
import com.fr.base.Style;
import com.fr.base.XMLable;
import com.fr.base.core.ComparatorUtils;
import com.fr.base.core.list.IntList;
import com.fr.base.xml.XMLPrintWriter;
import com.fr.base.xml.XMLReadable;
import com.fr.base.xml.XMLableReader;
import com.fr.data.TableData;
import com.fr.data.condition.Condition;
import com.fr.data.core.DataUtils;
import com.fr.data.core.DataXMLUtils;
import com.fr.data.impl.RowsTableData;
import com.fr.report.cellElement.Formula;
import com.fr.report.cellElement.TableDataColumn;
import com.fr.report.core.PaintUtils;
import com.fr.report.io.xml.ReportXMLUtils;
import com.fr.report.painter.AbstractPainter;
import com.fr.report.parameter.Parameter;
import com.fr.report.script.Calculator;
import com.fr.report.script.SingleRowNameSpace;
import com.fr.report.script.core.parser.UtilEvalError;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

public class DSColumn extends AbstractPainter
{
  private String dsName;
  private TableDataColumn column;
  private boolean reselect = false;
  private Condition condition;
  private RecordGrouper grouper;
  private Parameter[] parameters;
  private int order = 0;
  private String sortFormula = null;
  private Comparator sortComparator = null;
  private SelectCount selectCount = null;
  private String result = null;

  public String getDSName()
  {
    return this.dsName;
  }

  public void setDSName(String paramString)
  {
    this.dsName = paramString;
  }

  public Parameter[] getParameters()
  {
    return ((this.parameters == null) ? new Parameter[0] : this.parameters);
  }

  public void setParameters(Parameter[] paramArrayOfParameter)
  {
    this.parameters = paramArrayOfParameter;
  }

  /**
   * @deprecated
   */
  public String getColumnName()
  {
    return TableDataColumn.getColumnName(this.column);
  }

  /**
   * @deprecated
   */
  public void setColumnName(String paramString)
  {
    this.column = TableDataColumn.createColumn(paramString);
  }

  public TableDataColumn getColumn()
  {
    return this.column;
  }

  public void setColumn(TableDataColumn paramTableDataColumn)
  {
    this.column = paramTableDataColumn;
  }

  public Condition getCondition()
  {
    return this.condition;
  }

  public void setCondition(Condition paramCondition)
  {
    this.condition = paramCondition;
  }

  public RecordGrouper getGrouper()
  {
    if (this.grouper == null)
      this.grouper = new FunctionGrouper();
    return this.grouper;
  }

  public void setGrouper(RecordGrouper paramRecordGrouper)
  {
    this.grouper = paramRecordGrouper;
  }

  public int getOrder()
  {
    return this.order;
  }

  public void setOrder(int paramInt)
  {
    this.order = paramInt;
  }

  public String getSortFormula()
  {
    return this.sortFormula;
  }

  public void setSortFormula(String paramString)
  {
    this.sortFormula = paramString;
  }

  public Comparator getSortComparator()
  {
    return this.sortComparator;
  }

  public void setSortComparator(Comparator paramComparator)
  {
    this.sortComparator = paramComparator;
  }

  public boolean isReselect()
  {
    return this.reselect;
  }

  public void setReselect(boolean paramBoolean)
  {
    this.reselect = paramBoolean;
  }

  public SelectCount getSelectCount()
  {
    return this.selectCount;
  }

  public void setSelectCount(SelectCount paramSelectCount)
  {
    this.selectCount = paramSelectCount;
  }

  public String getResult()
  {
    return this.result;
  }

  public void setResult(String paramString)
  {
    this.result = paramString;
  }

  public void clearAdvanced()
  {
    this.grouper = null;
    this.order = 0;
    this.sortFormula = null;
    this.sortComparator = null;
    this.selectCount = null;
    this.result = null;
  }

  public Iterator dataIterator(TableData paramTableData, int paramInt, int[] paramArrayOfInt, Calculator paramCalculator)
  {
    return new DataIterator(this, getGrouper().groupIterator(paramTableData, paramInt, paramArrayOfInt, paramCalculator), paramTableData, paramCalculator);
  }

  public Group[] dealwith_condition_group_sort_select_result(TableData paramTableData, int paramInt, int[] paramArrayOfInt, Calculator paramCalculator)
  {
    paramArrayOfInt = (getCondition() == null) ? paramArrayOfInt : getCondition().evalTableData(paramTableData, paramArrayOfInt, paramInt, paramCalculator);
    return dealwith_result(dealwith_select(dealwith_sort(getGrouper().group(paramTableData, paramInt, paramArrayOfInt, paramCalculator), paramTableData, paramCalculator), paramCalculator), paramTableData, paramCalculator);
  }

  private Group[] dealwith_sort(Group[] paramArrayOfGroup, TableData paramTableData, Calculator paramCalculator)
  {
    if (this.order == 0)
      return paramArrayOfGroup;
    GroupComparable[] arrayOfGroupComparable = new GroupComparable[paramArrayOfGroup.length];
    for (int i = 0; i < arrayOfGroupComparable.length; ++i)
    {
      Group localGroup = paramArrayOfGroup[i];
      Object localObject = null;
      if (this.sortFormula == null)
      {
        localObject = localGroup.getValue();
      }
      else
      {
        paramCalculator.setCurrentRowsTableData(new RowsTableData(paramTableData, localGroup.getArray()));
        SingleRowNameSpace localSingleRowNameSpace = new SingleRowNameSpace(paramTableData, -1, localGroup.getValue());
        paramCalculator.pushNameSpace(localSingleRowNameSpace);
        if (this.sortFormula.startsWith("="))
          this.sortFormula = this.sortFormula.substring(1);
        try
        {
          localObject = paramCalculator.eval(this.sortFormula);
        }
        catch (UtilEvalError localUtilEvalError)
        {
          String str = "error happens at DSColumn.sort\nformula expression is " + this.sortFormula + "\nerror message is " + localUtilEvalError.getMessage();
          FRContext.getLogger().log(Level.WARNING, str, localUtilEvalError);
        }
        paramCalculator.removeNameSpace(localSingleRowNameSpace);
        paramCalculator.setCurrentRowsTableData(null);
      }
      arrayOfGroupComparable[i] = new GroupComparable(localGroup, localObject);
    }
    Arrays.sort(arrayOfGroupComparable, new GroupComparableComparator(this.sortComparator, this.order));
    for (i = 0; i < arrayOfGroupComparable.length; ++i)
      paramArrayOfGroup[i] = GroupComparable.access$000(arrayOfGroupComparable[i]);
    return paramArrayOfGroup;
  }

  private Group[] dealwith_select(Group[] paramArrayOfGroup, Calculator paramCalculator)
  {
    Group[] arrayOfGroup;
    int j;
    if (this.selectCount == null)
      return paramArrayOfGroup;
    String str1 = this.selectCount.getFormulaCount();
    int i = -1;
    if (StringUtils.isNotBlank(str1))
      try
      {
        i = Integer.parseInt(paramCalculator.eval(str1).toString());
      }
      catch (Exception localException)
      {
        String str2 = "error happens at calculating DSColumn, SelectCount's formula\nformula expression is " + str1 + "\nerror message is " + localException.getMessage();
        FRContext.getLogger().log(Level.WARNING, str2, localException);
      }
    switch (this.selectCount.getType())
    {
    case 1:
      i = (i < 0) ? paramArrayOfGroup.length : Math.min(i, paramArrayOfGroup.length);
      arrayOfGroup = new Group[i];
      System.arraycopy(paramArrayOfGroup, 0, arrayOfGroup, 0, i);
      break;
    case 2:
      i = (i < 0) ? paramArrayOfGroup.length : Math.min(i, paramArrayOfGroup.length);
      arrayOfGroup = new Group[i];
      System.arraycopy(paramArrayOfGroup, paramArrayOfGroup.length - i, arrayOfGroup, 0, i);
      break;
    case 3:
      i = paramArrayOfGroup.length / 2 + paramArrayOfGroup.length % 2;
      arrayOfGroup = new Group[i];
      j = 0;
      while (true)
      {
        if (j >= i)
          break label471;
        arrayOfGroup[j] = paramArrayOfGroup[(j * 2)];
        ++j;
      }
    case 4:
      i = paramArrayOfGroup.length / 2;
      arrayOfGroup = new Group[i];
      j = 0;
      while (true)
      {
        if (j >= i)
          break label471;
        arrayOfGroup[j] = paramArrayOfGroup[(j * 2 + 1)];
        ++j;
      }
    default:
      String str3 = this.selectCount.getSerial();
      if ((StringUtils.isNotBlank(str3)) && (str3.startsWith("=")))
        try
        {
          str3 = paramCalculator.eval(str3.substring(1)).toString();
        }
        catch (UtilEvalError localUtilEvalError)
        {
          FRContext.getLogger().log(Level.WARNING, localUtilEvalError.getMessage(), localUtilEvalError);
        }
      int[] arrayOfInt = IntList.toIntArrayDecimal(str3, ',');
      if ((arrayOfInt != null) && (arrayOfInt.length > 0))
      {
        ArrayList localArrayList = new ArrayList();
        int k = 0;
        int l = arrayOfInt.length;
        while (k < l)
        {
          int i1 = arrayOfInt[k] - 1;
          if ((i1 < paramArrayOfGroup.length) && (i1 >= 0))
            localArrayList.add(paramArrayOfGroup[i1]);
          ++k;
        }
        arrayOfGroup = new Group[localArrayList.size()];
        localArrayList.toArray(arrayOfGroup);
        break label471:
      }
      arrayOfGroup = paramArrayOfGroup;
    }
    label471: return arrayOfGroup;
  }

  private Group[] dealwith_result(Group[] paramArrayOfGroup, TableData paramTableData, Calculator paramCalculator)
  {
    if (this.result == null)
      return paramArrayOfGroup;
    String str1 = (this.result.startsWith("=")) ? this.result.substring(1) : this.result;
    if (("$$$".equals(str1)) || ("".equals(str1)))
      return paramArrayOfGroup;
    for (int i = 0; i < paramArrayOfGroup.length; ++i)
    {
      Group localGroup = paramArrayOfGroup[i];
      SingleRowNameSpace localSingleRowNameSpace = null;
      if ((localGroup.getArray() != null) && (localGroup.getArray().length > 0) && (paramTableData != null))
      {
        localSingleRowNameSpace = new SingleRowNameSpace(paramTableData, localGroup.getArray()[0], localGroup.getValue());
        paramCalculator.pushNameSpace(localSingleRowNameSpace);
      }
      try
      {
        localGroup.setValue(paramCalculator.eval(str1));
      }
      catch (UtilEvalError localUtilEvalError)
      {
        String str2 = "error happens at calculate formula\nformula expression is " + str1 + "\nerror message is " + localUtilEvalError.getMessage();
        FRContext.getLogger().log(Level.WARNING, str2, localUtilEvalError);
      }
      if (localSingleRowNameSpace != null)
        paramCalculator.removeNameSpace(localSingleRowNameSpace);
    }
    return paramArrayOfGroup;
  }

  public void paint(Graphics paramGraphics, int paramInt1, int paramInt2, Style paramStyle)
  {
    PaintUtils.paintCellStyleString((Graphics2D)paramGraphics, paramInt1, paramInt2, toString(), paramStyle);
  }

  public String toString()
  {
    StringBuffer localStringBuffer = new StringBuffer();
    localStringBuffer.append(this.dsName).append('.');
    if (this.reselect)
      localStringBuffer.append("(R)");
    if ((this.grouper instanceof FunctionGrouper) && (((FunctionGrouper)this.grouper).getDivideMode() == 1))
    {
      localStringBuffer.append("S(");
      localStringBuffer.append(this.column);
      localStringBuffer.append(")");
    }
    else if (this.grouper instanceof MonoGrouper)
    {
      localStringBuffer.append("S(");
      localStringBuffer.append(this.column);
      localStringBuffer.append(")");
    }
    else if (this.grouper instanceof SummaryGrouper)
    {
      localStringBuffer.append(DataUtils.getFunctionDisplayName(((SummaryGrouper)this.grouper).getFunction())).append("(");
      localStringBuffer.append(this.column);
      localStringBuffer.append(")");
    }
    else if (this.grouper instanceof IndexGrouper)
    {
      localStringBuffer.append(this.column);
    }
    else
    {
      localStringBuffer.append("G").append("(");
      localStringBuffer.append(this.column);
      localStringBuffer.append(")");
    }
    return localStringBuffer.toString();
  }

  public Object clone()
    throws CloneNotSupportedException
  {
    int i;
    DSColumn localDSColumn = (DSColumn)super.clone();
    if (this.column != null)
      localDSColumn.column = ((TableDataColumn)this.column.clone());
    if (this.condition != null)
      localDSColumn.condition = ((Condition)this.condition.clone());
    if (this.grouper != null)
      localDSColumn.grouper = ((RecordGrouper)this.grouper.clone());
    if (this.selectCount != null)
      localDSColumn.selectCount = ((SelectCount)this.selectCount.clone());
    if (this.parameters != null)
    {
      localDSColumn.parameters = new Parameter[this.parameters.length];
      for (i = 0; i < this.parameters.length; ++i)
        localDSColumn.parameters[i] = ((Parameter)this.parameters[i].clone());
    }
    return localDSColumn;
  }

  public void readXML(XMLableReader paramXMLableReader)
  {
    if (paramXMLableReader.isChildNode())
    {
      String str1;
      String str2 = paramXMLableReader.getTagName();
      if ("Attributes".equals(str2))
      {
        if ((str1 = paramXMLableReader.getAttr("dbName")) != null)
          setDSName(str1);
        if ((str1 = paramXMLableReader.getAttr("dsName")) != null)
          setDSName(str1);
        this.column = TableDataColumn.readXML(paramXMLableReader);
      }
      else if ("Condition".equals(str2))
      {
        this.condition = DataXMLUtils.readXMLCondition(paramXMLableReader);
      }
      else
      {
        Object localObject;
        if (str2.equals("Complex"))
        {
          if ((str1 = paramXMLableReader.getAttr("order")) != null)
            setOrder(Integer.parseInt(str1));
          if ((str1 = paramXMLableReader.getAttr("reselect")) != null)
            setReselect(str1.equalsIgnoreCase("true"));
          if ((str1 = paramXMLableReader.getAttr("type")) != null)
            switch (Integer.parseInt(str1))
            {
            case 1:
              setGrouper(new FunctionGrouper());
              break;
            case 2:
              localObject = new FunctionGrouper();
              ((FunctionGrouper)localObject).setDivideMode(1);
              setGrouper((RecordGrouper)localObject);
              break;
            case 3:
              setGrouper(new SummaryGrouper());
            }
          if ((str1 = paramXMLableReader.getAttr("function")) != null)
          {
            localObject = new SummaryGrouper();
            ((SummaryGrouper)localObject).setFunction(DataXMLUtils.readXMLDataFunction(str1));
            setGrouper((RecordGrouper)localObject);
          }
        }
        else if ("Result".equals(str2))
        {
          this.result = paramXMLableReader.getElementValue();
        }
        else if ("SortFormula".equals(str2))
        {
          this.sortFormula = paramXMLableReader.getElementValue();
          if (this.sortFormula == null)
            paramXMLableReader.readXMLObject(new XMLReadable(this)
            {
              private final DSColumn this$0;

              public void readXML()
              {
                if (paramXMLableReader.isChildNode())
                {
                  String str = paramXMLableReader.getTagName();
                  if (("Object".equals(str)) || ("O".equals(str)))
                  {
                    Object localObject = ReportXMLUtils.readObject(paramXMLableReader);
                    if (localObject instanceof Formula)
                      DSColumn.access$502(this.this$0, ((Formula)localObject).getContent());
                    else
                      DSColumn.access$502(this.this$0, localObject + "");
                  }
                }
              }
            });
        }
        else if ("Comparator".equals(str2))
        {
          this.sortComparator = DataXMLUtils.readXMLComparator(paramXMLableReader);
        }
        else if ("SelectCount".equals(str2))
        {
          this.selectCount = new SelectCount();
          paramXMLableReader.readXMLObject(this.selectCount);
        }
        else if ("RG".equals(str2))
        {
          this.grouper = ReportXMLUtils.readXMLRecordGrouper(paramXMLableReader);
        }
        else if ("Parameters".equals(str2))
        {
          localObject = new ArrayList();
          paramXMLableReader.readXMLObject(new XMLReadable(this, (List)localObject)
          {
            private final List val$tmpParameterList;
            private final DSColumn this$0;

            public void readXML()
            {
              if ("Parameter".equals(paramXMLableReader.getTagName()))
                this.val$tmpParameterList.add(ReportXMLUtils.readParameter(paramXMLableReader));
            }
          });
          if (((List)localObject).size() > 0)
          {
            this.parameters = new Parameter[((List)localObject).size()];
            ((List)localObject).toArray(this.parameters);
          }
        }
        else if (("Object".equals(str2)) || ("O".equals(str2)))
        {
          this.result = ((Formula)ReportXMLUtils.readObject(paramXMLableReader)).getContent();
        }
        else if ("GC".equals(str2))
        {
          setGrouper(ReportXMLUtils.readXMLRecordGrouper(paramXMLableReader));
        }
      }
    }
  }

  public void writeXML(XMLPrintWriter paramXMLPrintWriter)
  {
    paramXMLPrintWriter.startTAG("Attributes").attr("dsName", getDSName());
    TableDataColumn.writeXML(paramXMLPrintWriter, this.column);
    paramXMLPrintWriter.end();
    DataXMLUtils.writeXMLCondition(paramXMLPrintWriter, this.condition);
    paramXMLPrintWriter.startTAG("Complex");
    if (getOrder() != 0)
      paramXMLPrintWriter.attr("order", getOrder());
    if (isReselect())
      paramXMLPrintWriter.attr("reselect", "true");
    paramXMLPrintWriter.end();
    if (this.grouper != null)
      ReportXMLUtils.writeXMLable(paramXMLPrintWriter, this.grouper, "RG");
    if ((this.sortFormula != null) && (this.sortFormula.length() > 0))
      paramXMLPrintWriter.startTAG("SortFormula").textNode(this.sortFormula).end();
    if (this.sortComparator instanceof XMLable)
      DataXMLUtils.writeXMLComparator(paramXMLPrintWriter, this.sortComparator);
    if (this.selectCount != null)
      this.selectCount.writeXML(paramXMLPrintWriter);
    if (this.result != null)
      paramXMLPrintWriter.startTAG("Result").textNode(this.result).end();
    ReportXMLUtils.writeParameters(paramXMLPrintWriter, this.parameters);
  }

  static SelectCount access$200(DSColumn paramDSColumn)
  {
    return paramDSColumn.selectCount;
  }

  static Condition access$300(DSColumn paramDSColumn)
  {
    return paramDSColumn.condition;
  }

  static String access$400(DSColumn paramDSColumn)
  {
    return paramDSColumn.result;
  }

  static String access$502(DSColumn paramDSColumn, String paramString)
  {
    return (paramDSColumn.sortFormula = paramString);
  }

  private class DataIterator
    implements Iterator
  {
    private Iterator groupIterator;
    private Calculator calculator;
    private TableData tableData;
    private transient Group curGroup;
    private int next_count;
    private int select_count;
    private IntList selectList;
    private final DSColumn this$0;

    DataIterator(, Iterator paramIterator, TableData paramTableData, Calculator paramCalculator)
    {
      this.this$0 = paramDSColumn;
      this.curGroup = null;
      this.next_count = 0;
      this.select_count = -1;
      this.groupIterator = paramIterator;
      this.tableData = paramTableData;
      this.calculator = paramCalculator;
      if (DSColumn.access$200(paramDSColumn) != null)
      {
        String str1 = DSColumn.access$200(paramDSColumn).getFormulaCount();
        if (StringUtils.isNotBlank(str1))
          try
          {
            this.select_count = Integer.parseInt(paramCalculator.eval(str1).toString());
          }
          catch (Exception localException)
          {
            String str3 = "error happens at calculating DSColumn, SelectCount's formula\nformula expression is " + str1 + "\nerror message is " + localException.getMessage();
            FRContext.getLogger().log(Level.WARNING, str3, localException);
          }
        String str2 = DSColumn.access$200(paramDSColumn).getSerial();
        if ((StringUtils.isNotBlank(str2)) && (str2.startsWith("=")))
          try
          {
            str2 = paramCalculator.eval(str2.substring(1)).toString();
          }
          catch (UtilEvalError localUtilEvalError)
          {
            FRContext.getLogger().log(Level.WARNING, localUtilEvalError.getMessage(), localUtilEvalError);
          }
        arrayOfInt = IntList.toIntArrayDecimal(str2, ',');
        this.selectList = new IntList();
        for (i = 0; i < arrayOfInt.length; ++i)
          this.selectList.add(arrayOfInt[i]);
      }
    }

    public boolean hasNext()
    {
      while (true)
      {
        while (true)
        {
          while (true)
          {
            while (true)
            {
              while (true)
              {
                if (!(this.groupIterator.hasNext()))
                  break label220;
                this.next_count += 1;
                this.curGroup = ((Group)this.groupIterator.next());
                if (DSColumn.access$200(this.this$0) == null)
                  break label174;
                switch (DSColumn.access$200(this.this$0).getType())
                {
                case 1:
                  if (this.next_count <= this.select_count)
                    break label174;
                  this.curGroup = null;
                case 2:
                case 3:
                case 4:
                }
              }
              break label174:
              if (this.next_count % 2 == 1)
                break label174;
              this.curGroup = null;
            }
            if (this.next_count % 2 == 0)
              break label174;
            this.curGroup = null;
          }
          if ((this.selectList == null) || (this.selectList.contain(this.next_count)))
            break;
          this.curGroup = null;
        }
        label174: if ((DSColumn.access$300(this.this$0) == null) || (DSColumn.access$300(this.this$0).eval(this.curGroup.getValue(), this.calculator)))
          break;
        this.curGroup = null;
      }
      return true;
      label220: return false;
    }

    public Object next()
    {
      if (DSColumn.access$400(this.this$0) == null)
        return this.curGroup;
      String str1 = (DSColumn.access$400(this.this$0).startsWith("=")) ? DSColumn.access$400(this.this$0).substring(1) : DSColumn.access$400(this.this$0);
      if (("$$$".equals(str1)) || ("".equals(str1)))
        return this.curGroup;
      SingleRowNameSpace localSingleRowNameSpace = null;
      if ((this.curGroup.getArray() != null) && (this.curGroup.getArray().length > 0) && (this.tableData != null))
      {
        localSingleRowNameSpace = new SingleRowNameSpace(this.tableData, this.curGroup.getArray()[0], this.curGroup.getValue());
        this.calculator.pushNameSpace(localSingleRowNameSpace);
      }
      try
      {
        this.curGroup.setValue(this.calculator.eval(str1));
      }
      catch (UtilEvalError localUtilEvalError)
      {
        String str2 = "error happens at calculate formula\nformula expression is " + str1 + "\nerror message is " + localUtilEvalError.getMessage();
        FRContext.getLogger().log(Level.WARNING, str2, localUtilEvalError);
        return this.curGroup;
      }
      if (localSingleRowNameSpace != null)
        this.calculator.removeNameSpace(localSingleRowNameSpace);
      return this.curGroup;
    }

    public void remove()
    {
      throw new UnsupportedOperationException();
    }
  }

  private static final class GroupComparableComparator
    implements Comparator
  {
    private Comparator comparator = null;
    private int order = 1;

    public GroupComparableComparator(Comparator paramComparator, int paramInt)
    {
      this.comparator = paramComparator;
      this.order = paramInt;
    }

    public int compare(Object paramObject1, Object paramObject2)
    {
      int i;
      if ((!(paramObject1 instanceof DSColumn.GroupComparable)) || (!(paramObject2 instanceof DSColumn.GroupComparable)))
        return 0;
      DSColumn.GroupComparable localGroupComparable1 = (DSColumn.GroupComparable)paramObject1;
      DSColumn.GroupComparable localGroupComparable2 = (DSColumn.GroupComparable)paramObject2;
      if (this.comparator == null)
        i = ComparatorUtils.compare(DSColumn.GroupComparable.access$100(localGroupComparable1), DSColumn.GroupComparable.access$100(localGroupComparable2));
      else
        i = this.comparator.compare(DSColumn.GroupComparable.access$100(localGroupComparable1), DSColumn.GroupComparable.access$100(localGroupComparable2));
      if (this.order == 1)
        return i;
      return (0 - i);
    }
  }

  private static final class GroupComparable
  {
    private Group group;
    private Object comparable;

    public GroupComparable(Group paramGroup, Object paramObject)
    {
      this.group = paramGroup;
      this.comparable = paramObject;
    }

    static Group access$000(GroupComparable paramGroupComparable)
    {
      return paramGroupComparable.group;
    }

    static Object access$100(GroupComparable paramGroupComparable)
    {
      return paramGroupComparable.comparable;
    }
  }
}